home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / jovept2.arc / SCREEN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1985-05-30  |  7.3 KB  |  383 lines
  1. /* screen.c */
  2.  
  3. /* JOVE/MSDOS. K. Mitchum 1/85 */
  4. /* Modifications for personal use only. */
  5. /* original code J. Payne LSRHS 5/83 */
  6. /* Ken Mitchum */
  7. /* University of Pittsburgh */
  8. /* Decision Systems Laboratory */
  9.  
  10. /*
  11.    Jonathan Payne at Lincoln-Sudbury Regional High School 5-25-83
  12.  
  13.    jove_screen.c
  14.  
  15.    Deals with writing output to the screen optimally i.e. it doesn't
  16.    write what is already there.  It keeps an exact image of the screen
  17.    in the Screen array.  */
  18.  
  19. #define SCREEN
  20. #include "jove.h"
  21. #include "temp.h"
  22. #include "term.h"
  23. #include "screen.h"
  24.  
  25. extern int    diffnum;
  26.  
  27.  
  28.  
  29. #define soutputc(c)    if (--n > 0) sputc(c); else { sputc('!'); goto outahere;}
  30. #define sputc(c)    ((*cursor != c) ? dosputc(c) : (cursor++, i_col++))
  31. #define OkayOut(c)    if (col++ >= StartCol) soutputc(c) else
  32.  
  33. int    CheckTime;
  34.  
  35.  
  36. char *cursend;
  37. SCRLNE    *Screen,    /* The screen */
  38.             *Curline;    /* Current line */
  39.  
  40. static char *cursor;            /* Offset into current line */
  41. static int i_line, i_col;
  42.  
  43.  
  44. make_scr()
  45. {
  46.     register int    i;
  47.     register SCRLNE    *ns;
  48.     register char    *nsp;
  49.  
  50.     nimage = (struct scrimage *) emalloc(LI * sizeof (struct scrimage));
  51.     oimage = (struct scrimage *) emalloc(LI * sizeof (struct scrimage));
  52.  
  53.     ns = Screen = (SCRLNE *)
  54.             emalloc(LI * sizeof(SCRLNE));
  55.  
  56.     nsp = (char *) emalloc(CO * LI);
  57.  
  58.     for (i = 0; i < LI; i++) {
  59.         ns->s_line = nsp;
  60.         nsp += CO;
  61.         ns->s_length = nsp - 1;        /* End of line */
  62.         ns++;
  63.     }
  64.     cl_scr();
  65. }
  66.  
  67. clrline(cp1, cp2)
  68. register char    *cp1, *cp2;
  69. {
  70.     while (cp1 <= cp2)
  71.         *cp1++ = ' ';
  72. }
  73.  
  74. cl_eol()
  75. {
  76.     if (InputPending || cursor > cursend)
  77.         return;
  78.  
  79.     if (cursor < Curline->s_length) {
  80.         clrline(cursor, Curline->s_length);
  81.         Curline->s_length = cursor;
  82.         Placur(i_line, i_col);
  83.         wipeline();
  84.     }
  85. }
  86.  
  87. cl_scr()
  88. {
  89.     register int    i;
  90.     register SCRLNE    *sp = Screen;
  91.  
  92.     for (i = 0; i < LI; i++, sp++) {
  93.         clrline(sp->s_line, sp->s_length);
  94.         sp->s_length = sp->s_line;
  95.         oimage[i].Line = 0;
  96.     }
  97.     wipescreen();
  98.     Placur(0, 0);
  99.     UpdMesg++;
  100. }
  101.  
  102.  
  103.  
  104. /* Output one character (if necessary) at the current position */
  105.  
  106.  
  107.  
  108. dosputc(c)
  109. register char    c;
  110. {
  111.     if (*cursor != c) {
  112.         Placur(i_line, i_col);
  113.         outchar(c);
  114.         CapCol++;
  115.         *cursor++ = c;
  116.         i_col++;
  117.     } else {
  118.         cursor++;
  119.         i_col++;
  120.     }
  121. }
  122.  
  123. /* Write `line' at the current position of `cursor'.  Stop when we
  124.    reach the end of the screen.  Aborts if there is a character
  125.    waiting.  */
  126.  
  127. swrite(line,mode)
  128. register char    *line;
  129. {
  130.     register char    c;
  131.     int    col = 0,
  132.         aborted = 0;
  133.     register int    n = cursend - cursor;
  134.  
  135.     if(mode) SetHL();
  136.  
  137.     while (c = *line++) {
  138.         if (CheckTime) {
  139.             flusho();
  140.             CheckTime = 0;
  141.             if (InputPending = charp()) {
  142.                 aborted = 1;
  143.                 break;
  144.             }
  145.         }
  146.         if (c == '\t') {
  147.             int    nchars;
  148.  
  149.             nchars = (tabstop - (col % tabstop));
  150.             col += nchars;
  151.  
  152.             while (nchars--)
  153.                 soutputc(' ')
  154.         } else if (c < 040 || c == '\177') {
  155.             soutputc('^')
  156.             soutputc(c == '\177' ? '?' : c + '@')
  157.             col += 2;
  158.         } else {
  159.             soutputc(c)
  160.             col++;
  161.         }
  162.     }
  163. outahere:
  164.     if (cursor > Curline->s_length)
  165.         Curline->s_length = cursor;
  166.     if(mode) UnSetHL();
  167.     return !aborted;
  168.  
  169. }
  170.  
  171. /* This is for writing a buffer line to the screen.  This is to
  172.  * minimize the amount of copying from one buffer to another buffer.
  173.  * This gets the info directly from ibuff[12].
  174.  */
  175.  
  176. BufSwrite(linenum)
  177. {
  178.     register char    c,
  179.             *bp;
  180.     LINE    *lp = nimage[linenum].Line;
  181.     register int    n = cursend - cursor;
  182.     int    tl = lp->l_dline,
  183.         nl,
  184.         col = 0,
  185.         StartCol = nimage[linenum].StartCol,
  186.         aborted = 0;
  187.  
  188.  
  189.  
  190.     if (lp == curline) {
  191.         bp = linebuf;
  192.         nl = BUFSIZ;
  193.     } else {
  194.         bp = getblock(tl, READ);
  195.         nl = nleft;
  196.         tl &= ~OFFMSK;
  197.     }
  198.  
  199.     while (c = *bp++) {
  200.         if (CheckTime) {
  201.             flusho();
  202.             CheckTime = 0;
  203.             if (InputPending = charp()) {
  204.                 aborted = 1;
  205.                 break;
  206.             }
  207.         }
  208.         if (c == '\t') {
  209.             int    nchars;
  210.  
  211.             nchars = (tabstop - (col % tabstop));
  212.  
  213.             while (nchars--)
  214.                 OkayOut(' ');
  215.  
  216.         } else if (c < 040 || c == '\177') {
  217.             OkayOut('^');
  218.             OkayOut(c == '\177' ? '?' : c + '@');
  219.         } else
  220.             OkayOut(c);
  221.  
  222.         if (--nl == 0) {
  223.             bp = getblock(tl += INCRMT, READ);
  224.             nl = nleft;
  225.         }
  226.     }
  227. outahere:
  228.     if (cursor > Curline->s_length)
  229.         Curline->s_length = cursor;
  230.     return !aborted;        /* Didn't abort */
  231. }
  232.  
  233. putstr(str)
  234. register char    *str;
  235. {
  236.     register char    c;
  237.  
  238.     while (c = *str++)
  239.         outchar(c);
  240. }
  241.  
  242. i_set(nline, ncol)
  243. register int    nline,
  244.         ncol;
  245. {
  246.     Curline = &Screen[nline];
  247.     cursor = Curline->s_line + ncol;
  248.     cursend = &Curline->s_line[CO - 1];
  249.     i_line = nline;
  250.     i_col = ncol;
  251. }
  252.  
  253.  
  254.  
  255.  
  256. /*------------------------o.s. dependent--------------------------*/
  257. #ifdef UNIX
  258.  
  259. /* Insert `num' lines a top, but leave all the lines BELOW `bottom'
  260.  * alone (at least they won't look any different when we are done).
  261.  * This changes the screen array AND does the physical changes.
  262.  */
  263.  
  264. v_ins_line(num, top, bottom)
  265. {
  266.     register int    i;
  267.     SCRLNE    savelines[MAXNLINES];
  268.  
  269.     /* Save the screen pointers. */
  270.  
  271.     for(i = 0; i < num && top + i <= bottom; i++) {
  272.  
  273.  
  274.         savelines[i] = Screen[bottom - i];    /***/
  275.     }
  276.     /* Num number of bottom lines will be lost.
  277.      * Copy everything down num number of times.
  278.      */
  279.  
  280.     for (i = bottom; i > top && i-num >= 0; i--) {
  281.  
  282.         Screen[i] = Screen[i - num];    /***/
  283.     }
  284.  
  285.     /* Restore the saved ones, making them blank. */
  286.  
  287.     for (i = 0; i < num; i++) {
  288.  
  289.         Screen[top + i] = savelines[i];    /***/
  290.         clrline(Screen[top + i].s_line, Screen[top + i].s_length);
  291.     }
  292.  
  293.         Placur(bottom - num + 1, 0);
  294.         dellines(num);
  295.         Placur(top, 0);
  296.         inslines(num);
  297. }
  298.  
  299.  
  300.  
  301.  
  302. /* Delete `num' lines starting at `top' leaving the lines below `bottom'
  303.    alone.  This updates the internal image as well as the physical image.  */
  304.  
  305. v_del_line(num, top, bottom)
  306. {
  307.     register int    i,
  308.             bot;
  309.     SCRLNE    savelines[MAXNLINES];
  310.  
  311.     bot = bottom;
  312.  
  313.     /* Save the lost lines. */
  314.  
  315.     for (i = 0; i < num && top + i <= bottom; i++) {
  316.  
  317.         savelines[i] = Screen[top + i];    /***/
  318.     }
  319.     /* Copy everything up num number of lines. */
  320.  
  321.     for (i = top; num + i <= bottom; i++) {
  322.  
  323.         Screen[i] = Screen[i + num];    /***/
  324.  
  325.     }
  326.  
  327.     /* Restore the lost ones, clearing them. */
  328.  
  329.     for (i = 0; i < num; i++) {
  330.  
  331.         Screen[bottom - i] = savelines[i];    /***/
  332.         clrline(Screen[bot].s_line, Screen[bot].s_length);
  333.         bot--;
  334.     }
  335.  
  336.         Placur(top, 0);
  337.         dellines(num);
  338.         Placur(bottom + 1 - num, 0);
  339.         inslines(num);
  340.  
  341. }
  342.  
  343.  
  344. #else
  345.  
  346. v_ins_line(num,top,bottom)
  347. {
  348.     int p;
  349.     SCRLNE savelines[MAXNLINES];
  350.  
  351.     p = sizeof(SCRLNE);
  352.     
  353.     movmem(Screen + bottom - num +1,savelines,num * p);
  354.     movmem(Screen + top,Screen + top + num,(bottom - num - top +1) * p);
  355.     movmem(savelines,Screen + top,num * p);
  356.     for(p = 0; p < num; p++)
  357.         clrline(Screen[top + p].s_line, Screen[top + p].s_length);
  358.     Placur(bottom - num + 1, 0);
  359.     dellines(num,bottom);
  360.     Placur(top, 0);
  361.     inslines(num,bottom);
  362. }
  363.  
  364. v_del_line(num,top,bottom)
  365. {
  366.     int p;
  367.     SCRLNE savelines[MAXNLINES];
  368.     
  369.     p = sizeof(SCRLNE);
  370.     
  371.     movmem(Screen + top,savelines,num * p);
  372.     movmem(Screen + top + num,Screen + top, (bottom - num - top +1) *p);
  373.     movmem(savelines,Screen + bottom - num + 1,num *p);
  374.     for(p = 0; p < num; p++)
  375.         clrline(Screen[bottom - p].s_line,Screen[bottom -p].s_length);
  376.  
  377.     Placur(top, 0);
  378.     dellines(num,bottom);
  379.     Placur(bottom + 1 - num, 0);
  380.     inslines(num,bottom);
  381. }
  382. #endif
  383.